home *** CD-ROM | disk | FTP | other *** search
/ FM Towns: Free Software Collection 4 / FM Towns Free Software Collection 4 - Disc 1.iso / t_os / wstype / source / bufmgr.c < prev    next >
C/C++ Source or Header  |  1991-10-18  |  6KB  |  264 lines
  1. /***   [bufmgr.c]
  2. *
  3. *    テキストデータ構造 関連        (C)ささがわ
  4. *
  5. *    For GNU C Compiler (GCC)   Version 1.39
  6. *
  7. ***/
  8.  
  9. #include <io.h>
  10. #include <stdio.h>
  11. #include <stdlib.h>
  12. #include <string.h>
  13. #include <jctype.h>
  14. #include "bufmgr.h"
  15.  
  16. static unsigned char    *Buf_head;
  17. static size_t    Buf_size;
  18. static int        Buf_ptr;
  19.  
  20. static unsigned short    mgetc(void);
  21. static void    ctype_sub(int, int, int, int, unsigned char *, int *, int *, int, int *, unsigned short *);
  22. static int    BMGR_change_sub(int, int, struct filestore_t *, int *, int);
  23.  
  24. int BMGR_set(const char *file, int keta, int tab, register struct filestore_t *fl) {
  25.     FILE    *fp;
  26.     int     i, dum = -1;
  27.     
  28.     if ((fp = fopen(file, "rt")) == NULL) {
  29.         return -2;
  30.     } else if ((fl->size = (size_t)filelength(fileno(fp))) < 0) {
  31.         fclose(fp);
  32.         return -2;
  33.     } else if ((fl->buf1 = malloc(fl->size)) == NULL) {
  34.         fclose(fp);
  35.         return -1;
  36.     }
  37.     
  38.     fl->size = fread(fl->buf1, 1, fl->size, fp);
  39.     if (ferror(fp)) {
  40.         fclose(fp);
  41.         free(fl->buf1);
  42.         return -2;
  43.     }
  44.     fclose(fp);
  45.     if ((fl->buf1 = realloc(fl->buf1, fl->size)) == NULL)
  46.         return -1;
  47.     
  48.     for (i = 0; i < fl->size; i++) {    /* Clean Up */
  49.         if (iskanji(fl->buf1[i])) {
  50.             i++;
  51.             if (i < fl->size) {
  52.                 if (!iskanji2(fl->buf1[i])) {
  53.                     fl->buf1[i - 1] = 0x81;
  54.                     fl->buf1[i] = 0x40;
  55.                 }
  56.             } else {
  57.                 fl->buf1[i - 1] = ' ';
  58.             }
  59.         } else if (fl->buf1[i] == '\0') {
  60.             fl->buf1[i] = ' ';
  61.         }
  62.     }
  63.     fl->buf2 = NULL;
  64.     if (BMGR_change(keta, tab, fl, &dum)) {
  65.         free(fl->buf1);
  66.         return -1;
  67.     }
  68.     
  69.     return 0;
  70. }
  71.  
  72. int BMGR_change(int keta, int tab, struct filestore_t *fl, int *line) {
  73.     int        a = 0, r, bsz, adb;
  74.     
  75.     if (*line >= 0)
  76.         a = fl->buf2[*line];
  77.     
  78.     adb = fl->size / 20;
  79.     if (adb < 10)    adb = 10;
  80.     bsz = adb;
  81.     while ((r = BMGR_change_sub(keta, tab, fl, &bsz, adb)) == -2);
  82.     
  83.     if (*line >= 0)
  84.         for (*line = 0; a >= fl->buf2[*line + 1]; (*line)++);
  85.     
  86.     return r;
  87. }
  88.  
  89. static int BMGR_change_sub(int keta, int tab, struct filestore_t *fl, int *bsz, int adb) {
  90.     if (free(fl->buf2), (fl->buf2 = malloc(*bsz * sizeof(size_t))) == NULL)
  91.         return -1;
  92.     
  93.     Buf_head = fl->buf1;
  94.     Buf_size = fl->size;
  95.     Buf_ptr = 0;
  96.     fl->buf2[fl->line = 0] = 0;
  97.     while (fl->buf2[fl->line] < fl->size) {
  98.         register int    k = 0, n = 0;
  99.         
  100.         Buf_ptr = fl->buf2[fl->line];
  101.         while (n < keta) {
  102.             register unsigned short    c;
  103.             
  104.             k++;
  105.             if ((c = mgetc()) == 0xffff) {
  106.                 k--;
  107.                 break;
  108.             } else if (c == '\t') {
  109.                 n = ((n / tab) + 1) * tab;
  110.             } else if (c == '\n') {
  111.                 break;
  112.             } else if (c > 0xff) {
  113.                 if (n + 1 >= keta) {
  114.                     k--;
  115.                     break;
  116.                 }
  117.                 k++;
  118.                 n += 2;
  119.             } else {
  120.                 n++;
  121.             }
  122.         }
  123.         if (fl->line + 1 >= *bsz) {
  124.             size_t    *p;
  125.             
  126.             p = fl->buf2;
  127.             if ((fl->buf2 = malloc((*bsz + adb) * sizeof(size_t))) == NULL) {
  128.                 fl->buf2 = p;
  129.                 *bsz += adb;
  130.                 
  131.                 return -2;
  132.             } else {
  133.                 memcpy(fl->buf2, p, *bsz * sizeof(size_t));
  134.                 free(p);
  135.                 *bsz += adb;
  136.             }
  137.         }
  138.         fl->buf2[fl->line + 1] = fl->buf2[fl->line] + k;
  139.         fl->line++;
  140.     }
  141.     if (fl->line + 1 < *bsz && (fl->buf2 = realloc(fl->buf2, (fl->line + 1) * sizeof(size_t))) == NULL)
  142.         return -1;
  143.     
  144.     return 0;
  145. }
  146.  
  147. static unsigned short mgetc(void) {
  148.     unsigned short  ret;
  149.     
  150.     if (Buf_ptr >= Buf_size) {
  151.         ret = 0xffff;
  152.     } else {
  153.         if (iskanji(Buf_head[Buf_ptr]))
  154.             ret = (Buf_head[Buf_ptr++] << 8) + Buf_head[Buf_ptr++];
  155.         else
  156.             ret = Buf_head[Buf_ptr++];
  157.     }
  158.     
  159.     return ret;
  160. }
  161.  
  162. #define TAB    (par->tab)
  163. #define L    (par->l)
  164. #define R    (par->r)
  165. void BMGR_String(struct bmgr_t *par, unsigned char *buf) {
  166.     register int    n, k = 0, ack = 0;
  167.     unsigned char    *str, *p;
  168.     
  169.     n = par->fs->buf2[par->line + 1] - par->fs->buf2[par->line];
  170.     str = par->fs->buf1 + par->fs->buf2[par->line];
  171.     
  172.     for (; k < n && ack < L; k++) {
  173.         if (str[k] == '\t') {
  174.             if ((ack += TAB - ack % TAB) >= L)
  175.                 strncpy((char *)buf, "          ", ack - L);
  176.         } else if (iskanji(str[k])) {
  177.             if ((ack += 2) > L)
  178.                 *buf = ' ';
  179.             k++;
  180.         } else {
  181.             ack++;
  182.         }
  183.     }
  184.     
  185.     p = buf - L;
  186.     for (; k < n && ack <= R; k++) {
  187.         if (str[k] == '\n') {
  188.             p[ack++] = par->crm ? 0x1f : ' ';
  189.         } else if (str[k] == '\t') {
  190.             int        c;
  191.             
  192.             c = TAB - ack % TAB;
  193.             strncpy((char *)(&p[ack]), "          ", c);
  194.             p[ack] = par->tabm ? 0x1c : ' ';
  195.             ack += c;
  196.             if (ack > R + 1)
  197.                 ack = R + 1;
  198.         } else if (iskanji(str[k])) {
  199.             p[ack++] = str[k++];
  200.             p[ack++] = str[k];
  201.             if (ack > R + 1) {
  202.                 ack = R + 1;
  203.                 p[ack - 1] = ' ';
  204.             }
  205.         } else {
  206.             p[ack++] = str[k];
  207.         }
  208.     }
  209.     
  210.     buf[ack - L < 0 ? 0 : ack - L] = '\0';
  211. }
  212. #undef TAB
  213. #undef L
  214. #undef R
  215.  
  216. void BMGR_ctype(struct bmgr_t *par, struct bmgrctype_t *ct) {
  217.     int        n, k = 0, ack = 0;
  218.     unsigned char    *str;
  219.     
  220.     n = par->fs->buf2[par->line + 1] - par->fs->buf2[par->line];
  221.     str = par->fs->buf1 + par->fs->buf2[par->line];
  222.     
  223.     ctype_sub(par->tabm, par->crm, par->tab, n, str, &k, &ack, par->l, &ct->l, &ct->lcode);
  224.     ctype_sub(par->tabm, par->crm, par->tab, n, str, &k, &ack, par->r, &ct->r, &ct->rcode);
  225. }
  226.  
  227. static void ctype_sub(int tabm, int crm, int tab, int n, register unsigned char *str, int *k, int *ack, int target, int *type, unsigned short *code) {
  228.     *type = 0;
  229.     for (; *k < n && *ack <= target; (*k)++) {
  230.         if (str[*k] == '\n') {
  231.             if (*ack == target) {
  232.                 *type = 1;
  233.                 *code = crm ? 0x1f : ' ';
  234.             }
  235.             (*ack)++;
  236.         } else if (str[*k] == '\t') {
  237.             if (*ack == target) {
  238.                 *type = 1;
  239.                 *code = tabm ? 0x1c : ' ';
  240.             } else if (*ack < target && target <= *ack + tab - *ack % tab) {
  241.                 *type = 1;
  242.                 *code = ' ';
  243.             }
  244.             *ack += tab - *ack % tab;
  245.         } else if (iskanji(str[*k])) {
  246.             if (*ack + 1 == target) {
  247.                 *type = 3;
  248.                 *code = (str[*k] << 8) + str[*k + 1];
  249.             } else if (*ack == target) {
  250.                 *type = 2;
  251.                 *code = (str[*k] << 8) + str[*k + 1];
  252.             }
  253.             *ack += 2;
  254.             (*k)++;
  255.         } else {
  256.             if (*ack == target) {
  257.                 *type = 1;
  258.                 *code = str[*k];
  259.             }
  260.             (*ack)++;
  261.         }
  262.     }
  263. }
  264.